home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / xml / sax / handler.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  12.0 KB  |  284 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''
  5. This module contains the core classes of version 2.0 of SAX for Python.
  6. This file provides only default classes with absolutely minimum
  7. functionality, from which drivers and applications can be subclassed.
  8.  
  9. Many of these classes are empty and are included only as documentation
  10. of the interfaces.
  11.  
  12. $Id: handler.py,v 1.11 2004/05/06 03:47:48 fdrake Exp $
  13. '''
  14. version = '2.0beta'
  15.  
  16. class ErrorHandler:
  17.     '''Basic interface for SAX error handlers.
  18.  
  19.     If you create an object that implements this interface, then
  20.     register the object with your XMLReader, the parser will call the
  21.     methods in your object to report all warnings and errors. There
  22.     are three levels of errors available: warnings, (possibly)
  23.     recoverable errors, and unrecoverable errors. All methods take a
  24.     SAXParseException as the only parameter.'''
  25.     
  26.     def error(self, exception):
  27.         '''Handle a recoverable error.'''
  28.         raise exception
  29.  
  30.     
  31.     def fatalError(self, exception):
  32.         '''Handle a non-recoverable error.'''
  33.         raise exception
  34.  
  35.     
  36.     def warning(self, exception):
  37.         '''Handle a warning.'''
  38.         print exception
  39.  
  40.  
  41.  
  42. class ContentHandler:
  43.     '''Interface for receiving logical document content events.
  44.  
  45.     This is the main callback interface in SAX, and the one most
  46.     important to applications. The order of events in this interface
  47.     mirrors the order of the information in the document.'''
  48.     
  49.     def __init__(self):
  50.         self._locator = None
  51.  
  52.     
  53.     def setDocumentLocator(self, locator):
  54.         """Called by the parser to give the application a locator for
  55.         locating the origin of document events.
  56.  
  57.         SAX parsers are strongly encouraged (though not absolutely
  58.         required) to supply a locator: if it does so, it must supply
  59.         the locator to the application by invoking this method before
  60.         invoking any of the other methods in the DocumentHandler
  61.         interface.
  62.  
  63.         The locator allows the application to determine the end
  64.         position of any document-related event, even if the parser is
  65.         not reporting an error. Typically, the application will use
  66.         this information for reporting its own errors (such as
  67.         character content that does not match an application's
  68.         business rules). The information returned by the locator is
  69.         probably not sufficient for use with a search engine.
  70.  
  71.         Note that the locator will return correct information only
  72.         during the invocation of the events in this interface. The
  73.         application should not attempt to use it at any other time."""
  74.         self._locator = locator
  75.  
  76.     
  77.     def startDocument(self):
  78.         '''Receive notification of the beginning of a document.
  79.  
  80.         The SAX parser will invoke this method only once, before any
  81.         other methods in this interface or in DTDHandler (except for
  82.         setDocumentLocator).'''
  83.         pass
  84.  
  85.     
  86.     def endDocument(self):
  87.         '''Receive notification of the end of a document.
  88.  
  89.         The SAX parser will invoke this method only once, and it will
  90.         be the last method invoked during the parse. The parser shall
  91.         not invoke this method until it has either abandoned parsing
  92.         (because of an unrecoverable error) or reached the end of
  93.         input.'''
  94.         pass
  95.  
  96.     
  97.     def startPrefixMapping(self, prefix, uri):
  98.         '''Begin the scope of a prefix-URI Namespace mapping.
  99.  
  100.         The information from this event is not necessary for normal
  101.         Namespace processing: the SAX XML reader will automatically
  102.         replace prefixes for element and attribute names when the
  103.         http://xml.org/sax/features/namespaces feature is true (the
  104.         default).
  105.  
  106.         There are cases, however, when applications need to use
  107.         prefixes in character data or in attribute values, where they
  108.         cannot safely be expanded automatically; the
  109.         start/endPrefixMapping event supplies the information to the
  110.         application to expand prefixes in those contexts itself, if
  111.         necessary.
  112.  
  113.         Note that start/endPrefixMapping events are not guaranteed to
  114.         be properly nested relative to each-other: all
  115.         startPrefixMapping events will occur before the corresponding
  116.         startElement event, and all endPrefixMapping events will occur
  117.         after the corresponding endElement event, but their order is
  118.         not guaranteed.'''
  119.         pass
  120.  
  121.     
  122.     def endPrefixMapping(self, prefix):
  123.         '''End the scope of a prefix-URI mapping.
  124.  
  125.         See startPrefixMapping for details. This event will always
  126.         occur after the corresponding endElement event, but the order
  127.         of endPrefixMapping events is not otherwise guaranteed.'''
  128.         pass
  129.  
  130.     
  131.     def startElement(self, name, attrs):
  132.         '''Signals the start of an element in non-namespace mode.
  133.  
  134.         The name parameter contains the raw XML 1.0 name of the
  135.         element type as a string and the attrs parameter holds an
  136.         instance of the Attributes class containing the attributes of
  137.         the element.'''
  138.         pass
  139.  
  140.     
  141.     def endElement(self, name):
  142.         '''Signals the end of an element in non-namespace mode.
  143.  
  144.         The name parameter contains the name of the element type, just
  145.         as with the startElement event.'''
  146.         pass
  147.  
  148.     
  149.     def startElementNS(self, name, qname, attrs):
  150.         '''Signals the start of an element in namespace mode.
  151.  
  152.         The name parameter contains the name of the element type as a
  153.         (uri, localname) tuple, the qname parameter the raw XML 1.0
  154.         name used in the source document, and the attrs parameter
  155.         holds an instance of the Attributes class containing the
  156.         attributes of the element.
  157.  
  158.         The uri part of the name tuple is None for elements which have
  159.         no namespace.'''
  160.         pass
  161.  
  162.     
  163.     def endElementNS(self, name, qname):
  164.         '''Signals the end of an element in namespace mode.
  165.  
  166.         The name parameter contains the name of the element type, just
  167.         as with the startElementNS event.'''
  168.         pass
  169.  
  170.     
  171.     def characters(self, content):
  172.         '''Receive notification of character data.
  173.  
  174.         The Parser will call this method to report each chunk of
  175.         character data. SAX parsers may return all contiguous
  176.         character data in a single chunk, or they may split it into
  177.         several chunks; however, all of the characters in any single
  178.         event must come from the same external entity so that the
  179.         Locator provides useful information.'''
  180.         pass
  181.  
  182.     
  183.     def ignorableWhitespace(self, whitespace):
  184.         '''Receive notification of ignorable whitespace in element content.
  185.  
  186.         Validating Parsers must use this method to report each chunk
  187.         of ignorable whitespace (see the W3C XML 1.0 recommendation,
  188.         section 2.10): non-validating parsers may also use this method
  189.         if they are capable of parsing and using content models.
  190.  
  191.         SAX parsers may return all contiguous whitespace in a single
  192.         chunk, or they may split it into several chunks; however, all
  193.         of the characters in any single event must come from the same
  194.         external entity, so that the Locator provides useful
  195.         information.'''
  196.         pass
  197.  
  198.     
  199.     def processingInstruction(self, target, data):
  200.         '''Receive notification of a processing instruction.
  201.  
  202.         The Parser will invoke this method once for each processing
  203.         instruction found: note that processing instructions may occur
  204.         before or after the main document element.
  205.  
  206.         A SAX parser should never report an XML declaration (XML 1.0,
  207.         section 2.8) or a text declaration (XML 1.0, section 4.3.1)
  208.         using this method.'''
  209.         pass
  210.  
  211.     
  212.     def skippedEntity(self, name):
  213.         '''Receive notification of a skipped entity.
  214.  
  215.         The Parser will invoke this method once for each entity
  216.         skipped. Non-validating processors may skip entities if they
  217.         have not seen the declarations (because, for example, the
  218.         entity was declared in an external DTD subset). All processors
  219.         may skip external entities, depending on the values of the
  220.         http://xml.org/sax/features/external-general-entities and the
  221.         http://xml.org/sax/features/external-parameter-entities
  222.         properties.'''
  223.         pass
  224.  
  225.  
  226.  
  227. class DTDHandler:
  228.     '''Handle DTD events.
  229.  
  230.     This interface specifies only those DTD events required for basic
  231.     parsing (unparsed entities and attributes).'''
  232.     
  233.     def notationDecl(self, name, publicId, systemId):
  234.         '''Handle a notation declaration event.'''
  235.         pass
  236.  
  237.     
  238.     def unparsedEntityDecl(self, name, publicId, systemId, ndata):
  239.         '''Handle an unparsed entity declaration event.'''
  240.         pass
  241.  
  242.  
  243.  
  244. class EntityResolver:
  245.     '''Basic interface for resolving entities. If you create an object
  246.     implementing this interface, then register the object with your
  247.     Parser, the parser will call the method in your object to
  248.     resolve all external entities. Note that DefaultHandler implements
  249.     this interface with the default behaviour.'''
  250.     
  251.     def resolveEntity(self, publicId, systemId):
  252.         '''Resolve the system identifier of an entity and return either
  253.         the system identifier to read from as a string, or an InputSource
  254.         to read from.'''
  255.         return systemId
  256.  
  257.  
  258. feature_namespaces = 'http://xml.org/sax/features/namespaces'
  259. feature_namespace_prefixes = 'http://xml.org/sax/features/namespace-prefixes'
  260. feature_string_interning = 'http://xml.org/sax/features/string-interning'
  261. feature_validation = 'http://xml.org/sax/features/validation'
  262. feature_external_ges = 'http://xml.org/sax/features/external-general-entities'
  263. feature_external_pes = 'http://xml.org/sax/features/external-parameter-entities'
  264. all_features = [
  265.     feature_namespaces,
  266.     feature_namespace_prefixes,
  267.     feature_string_interning,
  268.     feature_validation,
  269.     feature_external_ges,
  270.     feature_external_pes]
  271. property_lexical_handler = 'http://xml.org/sax/properties/lexical-handler'
  272. property_declaration_handler = 'http://xml.org/sax/properties/declaration-handler'
  273. property_dom_node = 'http://xml.org/sax/properties/dom-node'
  274. property_xml_string = 'http://xml.org/sax/properties/xml-string'
  275. property_encoding = 'http://www.python.org/sax/properties/encoding'
  276. property_interning_dict = 'http://www.python.org/sax/properties/interning-dict'
  277. all_properties = [
  278.     property_lexical_handler,
  279.     property_dom_node,
  280.     property_declaration_handler,
  281.     property_xml_string,
  282.     property_encoding,
  283.     property_interning_dict]
  284.